home *** CD-ROM | disk | FTP | other *** search
/ The Utilities Experience / The Utilities Experience - Volume 1.iso / software / misc / o-z / x-windows / mesa-amiwin / src / list.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-11-30  |  54.5 KB  |  2,547 lines
  1. /* list.c */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  1.2
  6.  * Copyright (C) 1995  Brian Paul  (brianp@ssec.wisc.edu)
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25. $Id: list.c,v 1.29 1995/11/03 17:38:16 brianp Exp $
  26.  
  27. $Log: list.c,v $
  28.  * Revision 1.29  1995/11/03  17:38:16  brianp
  29.  * removed unused variables, added casts for C++ compilation
  30.  *
  31.  * Revision 1.28  1995/11/02  14:56:31  brianp
  32.  * added several (Node *) casts per Steven Spitz
  33.  *
  34.  * Revision 1.27  1995/10/29  19:14:19  brianp
  35.  * added glPolygonOffsetEXT display list support
  36.  *
  37.  * Revision 1.26  1995/10/14  17:42:12  brianp
  38.  * added glClipPlane, glLightModel, and texture functions
  39.  *
  40.  * Revision 1.25  1995/10/04  19:35:07  brianp
  41.  * replaced gl_save_normal with gl_save_normal3fv and gl_save_normal3f
  42.  *
  43.  * Revision 1.24  1995/08/31  18:34:16  brianp
  44.  * added display list / glScissor support
  45.  *
  46.  * Revision 1.23  1995/08/01  21:51:40  brianp
  47.  * renamed gl_save_pixelZoom as gl_save_pixelzoom
  48.  *
  49.  * Revision 1.22  1995/08/01  20:53:35  brianp
  50.  * added glPixelZoom support
  51.  *
  52.  * Revision 1.21  1995/07/25  16:41:54  brianp
  53.  * made changes for using CC.VertexFunc pointer
  54.  *
  55.  * Revision 1.20  1995/07/24  20:34:16  brianp
  56.  * replaced memset() with MEMSET() and memcpy() with MEMCPY()
  57.  *
  58.  * Revision 1.19  1995/06/22  14:28:20  brianp
  59.  * added glStencilFunc, glStencilMask and glStencilOp support
  60.  *
  61.  * Revision 1.18  1995/06/12  15:52:56  brianp
  62.  * changed includes for copypix.h and drawpix.h
  63.  *
  64.  * Revision 1.17  1995/05/22  21:02:41  brianp
  65.  * Release 1.2
  66.  *
  67.  * Revision 1.16  1995/05/19  13:26:50  brianp
  68.  * added display list support for selection/name stack functions
  69.  *
  70.  * Revision 1.15  1995/05/18  14:46:19  brianp
  71.  * fixed texture deallocation infinite loop bug
  72.  *
  73.  * Revision 1.14  1995/05/17  13:16:26  brianp
  74.  * added more error checking:  GL_INVALID_OPERATION between begin/end
  75.  *
  76.  * Revision 1.13  1995/05/15  16:07:15  brianp
  77.  * implemented shared/nonshared display lists
  78.  *
  79.  * Revision 1.12  1995/05/12  16:57:22  brianp
  80.  * replaced CC.Mode!=0 with INSIDE_BEGIN_END
  81.  *
  82.  * Revision 1.11  1995/05/10  18:44:40  brianp
  83.  * added glTexImage support
  84.  *
  85.  * Revision 1.10  1995/04/19  13:48:18  brianp
  86.  * renamed occurances of near and far for SCO x86 Unix
  87.  *
  88.  * Revision 1.9  1995/04/08  15:26:37  brianp
  89.  * add gl_save_shademodel
  90.  *
  91.  * Revision 1.8  1995/03/13  15:58:23  brianp
  92.  * fixed bitmap bugs per Thorsten Ohl
  93.  *
  94.  * Revision 1.7  1995/03/09  19:06:05  brianp
  95.  * replaced gl_disable calls with gl_enable(GL_FALSE)
  96.  *
  97.  * Revision 1.6  1995/03/08  15:10:02  brianp
  98.  * added logicop and clear_index functions
  99.  *
  100.  * Revision 1.5  1995/03/04  19:29:44  brianp
  101.  * 1.1 beta revision
  102.  *
  103.  * Revision 1.4  1995/03/01  15:23:53  brianp
  104.  * fixed glListBase, glCallList, glCallLists semantics bug
  105.  *
  106.  * Revision 1.3  1995/02/24  17:27:40  brianp
  107.  * *** empty log message ***
  108.  *
  109.  * Revision 1.2  1995/02/24  15:28:00  brianp
  110.  * fixed destroy_list bug
  111.  *
  112.  * Revision 1.1  1995/02/24  14:24:47  brianp
  113.  * Initial revision
  114.  *
  115.  */
  116.  
  117.  
  118. /*
  119.  * display lists.
  120.  */
  121.  
  122.  
  123. #include <stdio.h>
  124. #include <stdlib.h>
  125. #include <string.h>
  126. #include "accum.h"
  127. #include "attrib.h"
  128. #include "bitmap.h"
  129. #include "clip.h"
  130. #include "context.h"
  131. #include "copypix.h"
  132. #include "draw.h"
  133. #include "drawpix.h"
  134. #include "enable.h"
  135. #include "eval.h"
  136. #include "feedback.h"
  137. #include "fog.h"
  138. #include "light.h"
  139. #include "logic.h"
  140. #include "macros.h"
  141. #include "pixel.h"
  142. #include "texture.h"
  143. #include "xform.h"
  144.  
  145.  
  146. /*
  147. public        list building        internal    display list
  148. gl function    function        function    node kind
  149. ----------------------------------------------------------------------
  150. glAccum        gl_save_acum        <same>        NODE_ACCUM
  151. glAlphaFunc    gl_save_alphafunc    <same>        NODE_ALPHA_FUNC
  152. glBegin        gl_save_begin        gl_begin    NODE_BEGIN
  153. glBitmap    gl_save_bitmap        gl_bitmap    NODE_BITMAP
  154. glBlendFunc    gl_save_blendfunc    <same>        NODE_BLEND_FUNC
  155. glCallList    gl_save_call        execute_list    NODE_CALL_LIST
  156. glCallLists    gl_save_call        execute_list    NODE_CALL_LIST_OFFSET
  157. glClear        gl_save_clear        gl_clear    NODE_CLEAR
  158. glClearAccum    gl_save_clearaccum    <same>        NODE_CLEAR_ACCUM
  159. glClearColor    gl_save_clearcolor    <same>        NODE_CLEAR_COLOR
  160. glClearDepth    gl_save_cleardepth    <same>        NODE_CLEAR_DEPTH
  161. glClearIndex    gl_save_clearindex    <same>        NODE_CLEAR_INDEX
  162. glClearStencil    gl_save_clearstencil    <same>        NODE_CLEAR_STENCIL
  163. glClipPlane     gl_save_clipplane       gl_clipplane    NODE_CLIP_PLANE
  164. glColor*    gl_save_color        gl_color    NODE_COLOR
  165. glColorMask    gl_save_colormask    <same>        NODE_COLOR_MASK
  166. glCopyPixels    gl_save_copypixels    gl_copypixels    NODE_COPY_PIXELS
  167. glCullFace    gl_save_cullface    <same>        NODE_CULL_FACE
  168. glDepthFunc    gl_save_depthfunc    <same>        NODE_DEPTH_FUNC
  169. glDepthMask    gl_save_depthmask    <same>        NODE_DEPTH_MASK
  170. glDepthRange    gl_save_depthrange    <same>        NODE_DEPTH_RANGE
  171. glDisable    gl_save_disable        gl_enable    NODE_DISABLE
  172. glDrawBuffer    gl_save_drawbuffer    <same>        NODE_DRAW_BUFFER
  173. glDrawPixels    gl_save_drawpixels    gl_drawpixels    NODE_DRAW_PIXELS
  174. glEdgeFlag*    gl_save_set_boolean    <none>        NODE_SET_BOOLEAN
  175. glEnable    gl_save_enable        gl_enable    NODE_ENABLE
  176. glEnd        gl_save_end        gl_end        NODE_END
  177. glEvalCoord1f    gl_save_evalcoord1    gl_evalcoord1    NODE_EVALCOORD1
  178. glEvalCoord1d    gl_save_evalcoord1    gl_evalcoord1    NODE_EVALCOORD1
  179. glEvalCoord2f    gl_save_evalcoord2    gl_evalcoord2    NODE_EVALCOORD2
  180. glEvalCoord2d    gl_save_evalcoord2    gl_evalcoord2    NODE_EVALCOORD2
  181. glEvalPoint1    gl_save_evalpoint1    <same>        NODE_EVALPOINT1
  182. glEvalPoint2    gl_save_evalpoint2    <same>        NODE_EVALPOINT2
  183. glEvalMesh1    gl_save_evalmesh1    <same>        NODE_EVALMESH1
  184. glEvalMesh2    gl_save_evalmesh2    <same>        NODE_EVALMESH2
  185. glFog        gl_save_fog        gl_fog        NODE_FOG
  186. glFrontFace    gl_save_frontface    <same>        NODE_FRONT_FACE
  187. glHint        gl_save_hint        <same>        NODE_HINT
  188. glIndex*    gl_save_index        gl_index    NODE_INDEX
  189. glIndexMask    gl_save_indexmask    <same>        NODE_INDEX_MASK
  190. glInitNames    gl_save_initnames    <same>        NODE_INIT_NAMES
  191. glLight*    gl_save_light        gl_light    NODE_LIGHT
  192. glLightModel*    gl_save_lightmodel    gl_lightmodel    NODE_LIGHT_MODEL
  193. glLineStipple    gl_save_linestipple    gl_line_stipple    NODE_LINE_STIPPLE
  194. glLineWidth    gl_save_linewidth    gl_line_width    NODE_LINE_WIDTH
  195. glListBase    gl_save_listbase    <same>        NODE_LIST_BASE
  196. glLoadMatrix    gl_save_loadmatrix    gl_load_matrix    NODE_LOAD_MATRIX
  197. glLoadName    gl_save_loadname    <same>        NODE_LOAD_NAME
  198. glLogicOp    gl_save_logicop        gl_logicop    NODE_LOGIC_OP
  199. glMap1f        gl_save_map1        gl_map1        NODE_MAP1
  200. glMap1d        gl_save_map1        gl_map1        NODE_MAP1
  201. glMap2f        gl_save_map2        gl_map2        NODE_MAP2
  202. glMap2d        gl_save_map2        gl_map2        NODE_MAP2
  203. glMapGrid1f    gl_save_mapgrid1    gl_mapgrid1    NODE_MAPGRID1
  204. glMapGrid1d    gl_save_mapgrid1    gl_mapgrid1    NODE_MAPGRID1
  205. glMapGrid2f    gl_save_mapgrid2    gl_mapgrid2    NODE_MAPGRID2
  206. glMapGrid2d    gl_save_mapgrid2    gl_mapgrid2    NODE_MAPGRID2
  207. glMaterial*    gl_save_material    gl_material    NODE_MATERIAL
  208. glMultMatrix    gl_save_multmatrix    gl_mult_matrix    NODE_MULT_MATRIX
  209. glNormal*    gl_save_normal        <none>        NODE_NORMAL
  210. glPassThrough    gl_save_passthrough    gl_passthrough    NODE_PASSTHROUGH
  211. glPixelMap    gl_save_pixelmap    gl_pixel_map    NODE_PIXEL_MAP
  212. glPixelZoom    gl_save_pixelzoom    <same>        NODE_PIXEL_ZOOM
  213. glPointSize    gl_save_pointsize    <same>       NODE_POINTSIZE
  214. glPolygonMode    gl_save_polygonmode    <same>        NODE_POLYGON_MODE
  215. glPolygonOffset gl_save_polygonoffset   <same>          NODE_POLYGON_OFFSET
  216. glPopAttrib    gl_save_popmatrix    gl_pop_attrib    NODE_POP_ATTRIB
  217. glPopMatrix    gl_save_popmatrix    gl_pop_matrix    NODE_POP_MATRIX
  218. glPopName    gl_save_popname        <same>        NODE_POP_NAME
  219. glPushAttrib    gl_save_pushmatrix    gl_push_attrib    NODE_PUSH_ATTRIB
  220. glPushMatrix    gl_save_pushmatrix    gl_push_matrix    NODE_PUSH_MATRIX
  221. glPushName    gl_save_pushname    <same>        NODE_PUSH_NAME
  222. glRasterPos*    gl_save_rasterpos    gl_rasterpos    NODE_RASTER_POS
  223. glReadBuffer    gl_save_readbuffer    <same>        NODE_READ_BUFFER
  224. glScissor       gl_save_scissor         <same>          NODE_SCISSOR
  225. glShadeModel    gl_save_shademodel    <same>        NODE_SHADE_MODEL
  226. glStencilFunc    gl_save_stencilfunc    <same>        NODE_STENCIL_FUNC
  227. glStencilMask    gl_save_stencilmask    <same>        NODE_STENCIL_MASK
  228. glStencilOp    gl_save_stencilop    <same>        NODE_STENCIL_OP
  229. glTexCoord*    gl_save_texcoord    <none>        NODE_TEXCOORD
  230. glTexEnv*       gl_save_texenv          gl_texinv       NODE_TEXENV
  231. glTexGen*       gl_save_texgen          gl_texgen       NODE_TEXGEN
  232. glTexParam*     gl_save_texparameter    gl_texparameter NODE_TEXPARAMETER
  233. glTexImage1D    gl_save_teximage1d    gl_teximage1d    NODE_TEXIMAGE1D
  234. glTexImage2D    gl_save_teximage2d    gl_teximage2d    NODE_TEXIMAGE2D
  235. glVertex*    gl_save_vertex        gl_vertex    NODE_VERTEX
  236. glViewport    gl_save_viewport    gl_viewport    NODE_VIEWPORT
  237. */
  238.  
  239.  
  240. /*
  241. Functions which aren't compiled but executed immediately:
  242.     glIsList
  243.     glGenLists
  244.     glDeleteLists
  245.     glEndList
  246.     glFeedbackBuffer
  247.     glSelectBuffer
  248.     glRenderMode
  249.     glReadPixels
  250.     glPixelStore
  251.     glFlush
  252.     glFinish
  253.     glIsEnabled
  254.     glGet*
  255.  
  256. Functions which cause errors if called while compile a display list:
  257.     glNewList
  258. */
  259.  
  260.  
  261.  
  262. /* How many nodes to allocate at a time: */
  263. #define BLOCK_SIZE 100
  264.  
  265.  
  266. /*
  267.  * Kinds of nodes:  (the fact that these identifiers are assigned consecutive
  268.  * integer values starting at 0 is very important, see NodeSize array usage)
  269.  */
  270. typedef enum {
  271.     NODE_ACCUM,
  272.     NODE_ALPHA_FUNC,
  273.         NODE_BEGIN,
  274.     NODE_BITMAP,
  275.     NODE_BLEND_FUNC,
  276.         NODE_CALL_LIST,
  277.         NODE_CALL_LIST_OFFSET,
  278.     NODE_CLEAR,
  279.     NODE_CLEAR_ACCUM,
  280.     NODE_CLEAR_COLOR,
  281.     NODE_CLEAR_DEPTH,
  282.     NODE_CLEAR_INDEX,
  283.     NODE_CLEAR_STENCIL,
  284.         NODE_CLIP_PLANE,
  285.     NODE_COLOR,
  286.     NODE_COLOR_MASK,
  287.     NODE_COPY_PIXELS,
  288.     NODE_CULL_FACE,
  289.     NODE_DEPTH_FUNC,
  290.     NODE_DEPTH_MASK,
  291.     NODE_DEPTH_RANGE,
  292.     NODE_DISABLE,
  293.     NODE_DRAW_BUFFER,
  294.     NODE_DRAW_PIXELS,
  295.     NODE_ENABLE,
  296.         NODE_END,
  297.     NODE_EVALCOORD1,
  298.     NODE_EVALCOORD2,
  299.     NODE_EVALMESH1,
  300.     NODE_EVALMESH2,
  301.     NODE_EVALPOINT1,
  302.     NODE_EVALPOINT2,
  303.     NODE_FOG,
  304.     NODE_FRONT_FACE,
  305.     NODE_HINT,
  306.     NODE_INDEX,
  307.     NODE_INDEX_MASK,
  308.     NODE_INIT_NAMES,
  309.     NODE_LIGHT,
  310.     NODE_LIGHT_MODEL,
  311.     NODE_LINE_STIPPLE,
  312.     NODE_LINE_WIDTH,
  313.     NODE_LIST_BASE,
  314.     NODE_LOAD_MATRIX,
  315.     NODE_LOAD_NAME,
  316.     NODE_LOGIC_OP,
  317.     NODE_MAP1,
  318.     NODE_MAP2,
  319.     NODE_MAPGRID1,
  320.     NODE_MAPGRID2,
  321.     NODE_MATERIAL,
  322.     NODE_MULT_MATRIX,
  323.         NODE_NORMAL,
  324.     NODE_PASSTHROUGH,
  325.     NODE_PIXEL_MAP,
  326.     NODE_PIXEL_ZOOM,
  327.     NODE_POINTSIZE,
  328.     NODE_POLYGON_MODE,
  329.     NODE_POLYGON_OFFSET,
  330.     NODE_POP_ATTRIB,
  331.     NODE_POP_MATRIX,
  332.     NODE_POP_NAME,
  333.     NODE_PUSH_ATTRIB,
  334.     NODE_PUSH_MATRIX,
  335.     NODE_PUSH_NAME,
  336.     NODE_RASTER_POS,
  337.     NODE_READ_BUFFER,
  338.     NODE_SCISSOR,
  339.     NODE_SET_BOOLEAN,
  340.     NODE_SET_ENUM,
  341.     NODE_SET_FLOAT,
  342.     NODE_SET_INT,
  343.     NODE_SET_UINT,
  344.     NODE_SHADE_MODEL,
  345.     NODE_STENCIL_FUNC,
  346.     NODE_STENCIL_MASK,
  347.     NODE_STENCIL_OP,
  348.     NODE_TEXCOORD,
  349.         NODE_TEXENV,
  350.         NODE_TEXGEN,
  351.         NODE_TEXPARAMETER,
  352.     NODE_TEXIMAGE1D,
  353.     NODE_TEXIMAGE2D,
  354.         NODE_VERTEX,
  355.     NODE_VIEWPORT,
  356.     /* The following two are meta nodes */
  357.     NODE_CONTINUE,
  358.     NODE_END_OF_LIST
  359. } Kind;
  360.  
  361.  
  362. /*
  363.  * Each command in the display list is stored as a sequence of adjacent
  364.  * nodes in memory.  Each node is the union of a variety of datatypes.
  365.  */
  366. typedef union node {
  367.     Kind        kind;
  368.     GLboolean    b;
  369.     GLbitfield    bf;
  370.     GLshort        s;
  371.     GLushort    us;
  372.     GLint        i;
  373.     GLuint        ui;
  374.     GLenum        e;
  375.     GLfloat        f;
  376.     GLvoid        *data;
  377.     void        *next;    /* If prev node's kind==NODE_CONTINUE */
  378. } Node;
  379.  
  380.  
  381.  
  382. /* Number of nodes of storage needed for each command: */
  383. static GLuint NodeSize[ NODE_CONTINUE ];
  384.  
  385.  
  386. /* Used while a display list is under construction: */
  387. static Node *CurrentListPtr;    /* Head of list being compiled */
  388. static GLuint CurrentListNum;    /* Number of the list being compiled */
  389. static Node *CurrentBlock;    /* Pointer to current block of nodes */
  390. static GLuint CurrentPos;    /* Index into current block of nodes */
  391.  
  392.  
  393.  
  394.  
  395. /**********************************************************************/
  396. /*****                           Private                          *****/
  397. /**********************************************************************/
  398.  
  399.  
  400. /*
  401.  * Return a pointer to the first of 'count' empty nodes.
  402.  */
  403. static Node *alloc_nodes( GLuint count )
  404. {
  405.    Node *n;
  406.  
  407.    if (CurrentPos + count + 2 > BLOCK_SIZE) {
  408.       /* This block is full */
  409.       n = CurrentBlock + CurrentPos;
  410.       n[0].kind = NODE_CONTINUE;
  411.       n[1].next = (Node *) malloc( sizeof(Node) * BLOCK_SIZE );
  412.       /* TODO: check for out of memory */
  413.       CurrentBlock = (Node *) n[1].next;
  414.       CurrentPos = 0;
  415.    }
  416.  
  417.    n = CurrentBlock + CurrentPos;
  418.    CurrentPos += count;
  419.    return n;
  420. }
  421.  
  422.  
  423.  
  424.  
  425. /*
  426.  * Destroy all nodes in a display list.
  427.  * Input:  list - list number in [0..]
  428.  */
  429. void destroy_list( GLuint list )
  430. {
  431.    Node *n, *block;
  432.    GLboolean done;
  433.  
  434.    block = n = CC.ListGroup->List[list];
  435.  
  436.    done = GL_FALSE;
  437.    while (!done) {
  438.       switch (n[0].kind) {
  439.      /* special cases first */
  440.      case NODE_MAP1:
  441.         gl_free_control_points( n[1].e, (GLfloat *) n[6].data );
  442.         n += NodeSize[n[0].kind];
  443.         break;
  444.      case NODE_MAP2:
  445.         gl_free_control_points( n[1].e, (GLfloat *) n[10].data );
  446.         n += NodeSize[n[0].kind];
  447.         break;
  448.      case NODE_DRAW_PIXELS:
  449.         free( n[5].data );
  450.         n += NodeSize[n[0].kind];
  451.         break;
  452.      case NODE_BITMAP:
  453.         free( n[7].data );
  454.         n += NodeSize[n[0].kind];
  455.         break;
  456.      case NODE_TEXIMAGE1D:
  457.         {
  458.            GLint level = n[1].i;
  459.            if (CC.TextureImage1D[level]==n[5].data) {
  460.           /* this texture is currently in use, mark as deletable */
  461.           CC.TextureImage1DDeleteFlag[level] = GL_TRUE;
  462.            }
  463.            else {
  464.           /* this texture is not currently in use, delete it */
  465.           free( n[5].data );
  466.            }
  467.            n += NodeSize[n[0].kind];
  468.         }
  469.         break;
  470.      case NODE_TEXIMAGE2D:
  471.         {
  472.            GLint level = n[1].i;
  473.            if (CC.TextureImage2D[level]==n[6].data) {
  474.           /* this texture is currently in use, mark as deletable */
  475.           CC.TextureImage2DDeleteFlag[level] = GL_TRUE;
  476.            }
  477.            else {
  478.           /* this texture is not currently in use, delete it */
  479.           free( n[6].data );
  480.            }
  481.            n += NodeSize[n[0].kind];
  482.         }
  483.         break;
  484.      case NODE_CONTINUE:
  485.         n = (Node *) n[1].next;
  486.         free( block );
  487.         block = n;
  488.         break;
  489.      case NODE_END_OF_LIST:
  490.         free( block );
  491.         done = GL_TRUE;
  492.         break;
  493.      default:
  494.         /* Most frequent case */
  495.         n += NodeSize[n[0].kind];
  496.         break;
  497.       }
  498.    }
  499.  
  500.    CC.ListGroup->List[list] = NULL;
  501. }
  502.  
  503.  
  504.  
  505. /*
  506.  * Translate the nth element of list from type to GLuint.
  507.  */
  508. static GLuint translate_id( GLsizei n, GLenum type, const GLvoid *list )
  509. {
  510.    GLbyte *bptr;
  511.    GLubyte *ubptr;
  512.    GLshort *sptr;
  513.    GLushort *usptr;
  514.    GLint *iptr;
  515.    GLuint *uiptr;
  516.    GLfloat *fptr;
  517.  
  518.    switch (type) {
  519.       case GL_BYTE:
  520.          bptr = (GLbyte *) list;
  521.          return (GLuint) *(bptr+n);
  522.       case GL_UNSIGNED_BYTE:
  523.          ubptr = (GLubyte *) list;
  524.          return (GLuint) *(ubptr+n);
  525.       case GL_SHORT:
  526.          sptr = (GLshort *) list;
  527.          return (GLuint) *(sptr+n);
  528.       case GL_UNSIGNED_SHORT:
  529.          usptr = (GLushort *) list;
  530.          return (GLuint) *(usptr+n);
  531.       case GL_INT:
  532.          iptr = (GLint *) list;
  533.          return (GLuint) *(iptr+n);
  534.       case GL_UNSIGNED_INT:
  535.          uiptr = (GLuint *) list;
  536.          return (GLuint) *(uiptr+n);
  537.       case GL_FLOAT:
  538.          fptr = (GLfloat *) list;
  539.          return (GLuint) *(fptr+n);
  540.       case GL_2_BYTES:
  541.          ubptr = ((GLubyte *) list) + 2*n;
  542.          return (GLuint) *ubptr * 256 + (GLuint) *(ubptr+1);
  543.       case GL_3_BYTES:
  544.          ubptr = ((GLubyte *) list) + 3*n;
  545.          return (GLuint) *ubptr * 65536
  546.               + (GLuint) *(ubptr+1) * 256
  547.               + (GLuint) *(ubptr+2);
  548.       case GL_4_BYTES:
  549.          ubptr = ((GLubyte *) list) + 4*n;
  550.          return (GLuint) *ubptr * 16777216
  551.               + (GLuint) *(ubptr+1) * 65536
  552.               + (GLuint) *(ubptr+2) * 256
  553.               + (GLuint) *(ubptr+3);
  554.       default:
  555.          return 0;
  556.    }
  557. }
  558.  
  559.  
  560.  
  561.  
  562. /**********************************************************************/
  563. /*****                        Public                              *****/
  564. /**********************************************************************/
  565.  
  566. void gl_init_lists( void )
  567. {
  568.    static int init_flag = 0;
  569.  
  570.    if (init_flag==0) {
  571.       CurrentListPtr = CurrentBlock = NULL;
  572.       CurrentListNum = 0;
  573.  
  574.       NodeSize[NODE_ACCUM] = 3;
  575.       NodeSize[NODE_ALPHA_FUNC] = 3;
  576.       NodeSize[NODE_BEGIN] = 2;
  577.       NodeSize[NODE_BITMAP] = 8;
  578.       NodeSize[NODE_BLEND_FUNC] = 3;
  579.       NodeSize[NODE_CALL_LIST] = 2;
  580.       NodeSize[NODE_CALL_LIST_OFFSET] = 2;
  581.       NodeSize[NODE_CLEAR] = 2;
  582.       NodeSize[NODE_CLEAR_ACCUM] = 5;
  583.       NodeSize[NODE_CLEAR_COLOR] = 5;
  584.       NodeSize[NODE_CLEAR_DEPTH] = 2;
  585.       NodeSize[NODE_CLEAR_INDEX] = 2;
  586.       NodeSize[NODE_CLIP_PLANE] = 6;
  587.       NodeSize[NODE_COLOR] = 5;
  588.       NodeSize[NODE_COLOR_MASK] = 5;
  589.       NodeSize[NODE_COPY_PIXELS] = 6;
  590.       NodeSize[NODE_CULL_FACE] = 2;
  591.       NodeSize[NODE_DEPTH_FUNC] = 2;
  592.       NodeSize[NODE_DEPTH_MASK] = 2;
  593.       NodeSize[NODE_DEPTH_RANGE] = 3;
  594.       NodeSize[NODE_DISABLE] = 2;
  595.       NodeSize[NODE_DRAW_BUFFER] = 2;
  596.       NodeSize[NODE_DRAW_PIXELS] = 6;
  597.       NodeSize[NODE_ENABLE] = 2;
  598.       NodeSize[NODE_END] = 1;
  599.       NodeSize[NODE_EVALCOORD1] = 2;
  600.       NodeSize[NODE_EVALCOORD2] = 3;
  601.       NodeSize[NODE_EVALMESH1] = 4;
  602.       NodeSize[NODE_EVALMESH2] = 6;
  603.       NodeSize[NODE_EVALPOINT1] = 2;
  604.       NodeSize[NODE_EVALPOINT2] = 3;
  605.       NodeSize[NODE_FOG] = 6;
  606.       NodeSize[NODE_FRONT_FACE] = 2;
  607.       NodeSize[NODE_HINT] = 3;
  608.       NodeSize[NODE_INDEX] = 2;
  609.       NodeSize[NODE_INDEX_MASK] = 2;
  610.       NodeSize[NODE_INIT_NAMES] = 1;
  611.       NodeSize[NODE_LIGHT] = 7;
  612.       NodeSize[NODE_LIGHT_MODEL] = 6;
  613.       NodeSize[NODE_LINE_STIPPLE] = 3;
  614.       NodeSize[NODE_LINE_WIDTH] = 2;
  615.       NodeSize[NODE_LIST_BASE] = 2;
  616.       NodeSize[NODE_LOAD_MATRIX] = 17;
  617.       NodeSize[NODE_LOAD_NAME] = 2;
  618.       NodeSize[NODE_LOGIC_OP] = 2;
  619.       NodeSize[NODE_MAP1] = 7;
  620.       NodeSize[NODE_MAP2] = 11;
  621.       NodeSize[NODE_MAPGRID1] = 4;
  622.       NodeSize[NODE_MAPGRID2] = 7;
  623.       NodeSize[NODE_MATERIAL] = 7;
  624.       NodeSize[NODE_MULT_MATRIX] = 17;
  625.       NodeSize[NODE_NORMAL] = 4;
  626.       NodeSize[NODE_PASSTHROUGH] = 2;
  627.       NodeSize[NODE_PIXEL_MAP] = 4;
  628.       NodeSize[NODE_PIXEL_ZOOM] = 3;
  629.       NodeSize[NODE_POINTSIZE] = 2;
  630.       NodeSize[NODE_POLYGON_MODE] = 3;
  631.       NodeSize[NODE_POLYGON_OFFSET] = 3;
  632.       NodeSize[NODE_POP_ATTRIB] = 1;
  633.       NodeSize[NODE_POP_MATRIX] = 1;
  634.       NodeSize[NODE_POP_NAME] = 1;
  635.       NodeSize[NODE_PUSH_ATTRIB] = 2;
  636.       NodeSize[NODE_PUSH_MATRIX] = 1;
  637.       NodeSize[NODE_PUSH_NAME] = 2;
  638.       NodeSize[NODE_RASTER_POS] = 5;
  639.       NodeSize[NODE_READ_BUFFER] = 2;
  640.       NodeSize[NODE_SCISSOR] = 5;
  641.       NodeSize[NODE_SET_BOOLEAN] = 3;
  642.       NodeSize[NODE_SET_ENUM] = 3;
  643.       NodeSize[NODE_SET_FLOAT] = 3;
  644.       NodeSize[NODE_SET_INT] = 3;
  645.       NodeSize[NODE_SET_UINT] = 3;
  646.       NodeSize[NODE_STENCIL_FUNC] = 4;
  647.       NodeSize[NODE_STENCIL_MASK] = 2;
  648.       NodeSize[NODE_STENCIL_OP] = 4;
  649.       NodeSize[NODE_SHADE_MODEL] = 2;
  650.       NodeSize[NODE_TEXCOORD] = 5;
  651.       NodeSize[NODE_TEXENV] = 7;
  652.       NodeSize[NODE_TEXGEN] = 7;
  653.       NodeSize[NODE_TEXPARAMETER] = 7;
  654.       NodeSize[NODE_TEXIMAGE1D] = 6;
  655.       NodeSize[NODE_TEXIMAGE2D] = 7;
  656.       NodeSize[NODE_VERTEX] = 5;
  657.       NodeSize[NODE_VIEWPORT] = 5;
  658.    }
  659.    init_flag = 1;
  660. }
  661.  
  662.  
  663.  
  664. /*
  665.  * Return the name of the display list currently being compiled.  This
  666.  * function is only called by glGet().
  667.  */
  668. GLint gl_list_index( void )
  669. {
  670.    return CurrentListNum;
  671. }
  672.  
  673.  
  674.  
  675. /*
  676.  * Display List compilation functions
  677.  */
  678.  
  679.  
  680. void gl_save_accum( GLenum op, GLfloat value )
  681. {
  682.    Node *n = alloc_nodes(3);
  683.    if (n) {
  684.       n[0].kind = NODE_ACCUM;
  685.       n[1].e = op;
  686.       n[2].f = value;
  687.    }
  688. }
  689.  
  690.  
  691. void gl_save_alphafunc( GLenum func, GLclampf ref )
  692. {
  693.    Node *n = alloc_nodes(3);
  694.    if (n) {
  695.       n[0].kind = NODE_ALPHA_FUNC;
  696.       n[1].e = func;
  697.       n[2].f = (GLfloat) ref;
  698.    }
  699. }
  700.  
  701.  
  702. /*
  703.  * Compile a glBegin into current display list.
  704.  */
  705. void gl_save_begin( GLenum mode )
  706. {
  707.    Node *n = alloc_nodes(2);
  708.    if (n) {
  709.       n[0].kind = NODE_BEGIN;
  710.       n[1].e = mode;
  711.    }
  712. }
  713.  
  714.  
  715. void gl_save_bitmap( GLsizei width, GLsizei height,
  716.              GLfloat xorig, GLfloat yorig,
  717.              GLfloat xmove, GLfloat ymove,
  718.              const GLubyte *bitmap )
  719. {
  720.    Node *n = alloc_nodes(8);
  721.    if (n) {
  722.       n[0].kind = NODE_BITMAP;
  723.       n[1].i = (GLint) width;
  724.       n[2].i = (GLint) height;
  725.       n[3].f = xorig;
  726.       n[4].f = yorig;
  727.       n[5].f = xmove;
  728.       n[6].f = ymove;
  729.       n[7].data = (void *) bitmap;
  730.    }
  731. }
  732.  
  733.  
  734. void gl_save_blendfunc( GLenum sfactor, GLenum dfactor )
  735. {
  736.    Node *n = alloc_nodes(3);
  737.    if (n) {
  738.       n[0].kind = NODE_BLEND_FUNC;
  739.       n[1].e = sfactor;
  740.       n[2].e = dfactor;
  741.    }
  742. }
  743.  
  744.  
  745. void gl_save_clear( GLbitfield mask )
  746. {
  747.    Node *n = alloc_nodes(2);
  748.    if (n) {
  749.       n[0].kind = NODE_CLEAR;
  750.       n[1].bf = mask;
  751.    }
  752. }
  753.  
  754.  
  755. void gl_save_clearaccum( GLfloat red, GLfloat green,
  756.              GLfloat blue, GLfloat alpha )
  757. {
  758.    Node *n = alloc_nodes(5);
  759.    if (n) {
  760.       n[0].kind = NODE_CLEAR_ACCUM;
  761.       n[1].f = red;
  762.       n[2].f = green;
  763.       n[3].f = blue;
  764.       n[4].f = alpha;
  765.    }
  766. }
  767.  
  768.  
  769. void gl_save_clearcolor( GLclampf red, GLclampf green,
  770.              GLclampf blue, GLclampf alpha )
  771. {
  772.    Node *n = alloc_nodes(5);
  773.    if (n) {
  774.       n[0].kind = NODE_CLEAR_COLOR;
  775.       n[1].f = red;
  776.       n[2].f = green;
  777.       n[3].f = blue;
  778.       n[4].f = alpha;
  779.    }
  780. }
  781.  
  782.  
  783. void gl_save_cleardepth( GLclampd depth )
  784. {
  785.    Node *n = alloc_nodes(2);
  786.    if (n) {
  787.       n[0].kind = NODE_CLEAR_DEPTH;
  788.       n[1].f = (GLfloat) depth;
  789.    }
  790. }
  791.  
  792.  
  793. void gl_save_clearindex( GLfloat c )
  794. {
  795.    Node *n = alloc_nodes(2);
  796.    if (n) {
  797.       n[0].kind = NODE_CLEAR_INDEX;
  798.       n[1].f = c;
  799.    }
  800. }
  801.  
  802.  
  803. void gl_save_clearstencil( GLint s )
  804. {
  805.    Node *n = alloc_nodes(2);
  806.    if (n) {
  807.       n[0].kind = NODE_CLEAR_STENCIL;
  808.       n[1].i = s;
  809.    }
  810. }
  811.  
  812.  
  813. void gl_save_clipplane( GLenum plane, const GLfloat *equ )
  814. {
  815.    Node *n = alloc_nodes(6);
  816.    if (n) {
  817.       n[0].kind = NODE_CLIP_PLANE;
  818.       n[1].e = plane;
  819.       n[2].f = equ[0];
  820.       n[3].f = equ[1];
  821.       n[4].f = equ[2];
  822.       n[5].f = equ[3];
  823.    }
  824. }
  825.  
  826.  
  827.  
  828. /*
  829.  * Add a color to current display list.
  830.  */
  831. void gl_save_color( const GLfloat c[4] )
  832. {
  833.    Node *n = alloc_nodes(5);
  834.    if (n) {
  835.       n[0].kind = NODE_COLOR;
  836.       n[1].f = c[0];
  837.       n[2].f = c[1];
  838.       n[3].f = c[2];
  839.       n[4].f = c[3];
  840.    }
  841. }
  842.  
  843.  
  844. void gl_save_colormask( GLboolean red, GLboolean green,
  845.              GLboolean blue, GLboolean alpha )
  846. {
  847.    Node *n = alloc_nodes(5);
  848.    if (n) {
  849.       n[0].kind = NODE_COLOR_MASK;
  850.       n[1].b = red;
  851.       n[2].b = green;
  852.       n[3].b = blue;
  853.       n[4].b = alpha;
  854.    }
  855. }
  856.  
  857.  
  858. void gl_save_copypixels( GLint x, GLint y,
  859.              GLsizei width, GLsizei height, GLenum type )
  860. {
  861.    Node *n = alloc_nodes(6);
  862.    if (n) {
  863.       n[0].kind = NODE_COPY_PIXELS;
  864.       n[1].i = x;
  865.       n[2].i = y;
  866.       n[3].i = (GLint) width;
  867.       n[4].i = (GLint) height;
  868.       n[5].e = type;
  869.    }
  870.  
  871. }
  872.  
  873.  
  874.  
  875. void gl_save_cullface( GLenum mode )
  876. {
  877.    Node *n = alloc_nodes(2);
  878.    if (n) {
  879.       n[0].kind = NODE_CULL_FACE;
  880.       n[1].e = mode;
  881.    }
  882. }
  883.  
  884.  
  885. void gl_save_depthfunc( GLenum func )
  886. {
  887.    Node *n = alloc_nodes(2);
  888.    if (n) {
  889.       n[0].kind = NODE_DEPTH_FUNC;
  890.       n[1].e = func;
  891.    }
  892. }
  893.  
  894.  
  895. void gl_save_depthmask( GLboolean mask )
  896. {
  897.    Node *n = alloc_nodes(2);
  898.    if (n) {
  899.       n[0].kind = NODE_DEPTH_MASK;
  900.       n[1].b = mask;
  901.    }
  902. }
  903.  
  904.  
  905. void gl_save_depthrange( GLclampd nearval, GLclampd farval )
  906. {
  907.    Node *n = alloc_nodes(3);
  908.    if (n) {
  909.       n[0].kind = NODE_DEPTH_RANGE;
  910.       n[1].f = (GLfloat) nearval;
  911.       n[2].f = (GLfloat) farval;
  912.    }
  913. }
  914.  
  915.  
  916. void gl_save_disable( GLenum cap )
  917. {
  918.    Node *n = alloc_nodes(2);
  919.    if (n) {
  920.       n[0].kind = NODE_DISABLE;
  921.       n[1].e = cap;
  922.    }
  923. }
  924.  
  925.  
  926. void gl_save_drawbuffer( GLenum mode )
  927. {
  928.    Node *n = alloc_nodes(2);
  929.    if (n) {
  930.       n[0].kind = NODE_DRAW_BUFFER;
  931.       n[1].e = mode;
  932.    }
  933. }
  934.  
  935.  
  936. void gl_save_drawpixels( GLsizei width, GLsizei height, GLenum format,
  937.              GLenum type, GLvoid *pixels )
  938. {
  939.    Node *n = alloc_nodes(6);
  940.    if (n) {
  941.       n[0].kind = NODE_DRAW_PIXELS;
  942.       n[1].i = (GLint) width;
  943.       n[2].i = (GLint) height;
  944.       n[3].e = format;
  945.       n[4].e = type;
  946.       n[5].data = pixels;
  947.    }
  948. }
  949.  
  950.  
  951. void gl_save_enable( GLenum cap )
  952. {
  953.    Node *n = alloc_nodes(2);
  954.    if (n) {
  955.       n[0].kind = NODE_ENABLE;
  956.       n[1].e = cap;
  957.    }
  958. }
  959.  
  960.  
  961. /*
  962.  * Compile a glEnd into current display list.
  963.  */
  964. void gl_save_end( void )
  965. {
  966.    Node *n = alloc_nodes(1);
  967.    if (n) {
  968.       n[0].kind = NODE_END;
  969.    }
  970. }
  971.  
  972.  
  973.  
  974. void gl_save_evalcoord1( GLfloat u )
  975. {
  976.    Node *n = alloc_nodes(2);
  977.    if (n) {
  978.       n[0].kind = NODE_EVALCOORD1;
  979.       n[1].f = u;
  980.    }
  981. }
  982.  
  983.  
  984. void gl_save_evalcoord2( GLfloat u, GLfloat v )
  985. {
  986.    Node *n = alloc_nodes(3);
  987.    if (n) {
  988.       n[0].kind = NODE_EVALCOORD2;
  989.       n[1].f = u;
  990.       n[2].f = v;
  991.    }
  992. }
  993.  
  994.  
  995.  
  996. void gl_save_evalmesh1( GLenum mode, GLint i1, GLint i2 )
  997. {
  998.    Node *n = alloc_nodes(4);
  999.    if (n) {
  1000.       n[0].kind = NODE_EVALMESH1;
  1001.       n[1].e = mode;
  1002.       n[2].i = i1;
  1003.       n[3].i = i2;
  1004.    }
  1005. }
  1006.  
  1007.  
  1008.  
  1009. void gl_save_evalmesh2( GLenum mode, GLint i1, GLint i2,
  1010.                 GLint j1, GLint j2 )
  1011. {
  1012.    Node *n = alloc_nodes(6);
  1013.    if (n) {
  1014.       n[0].kind = NODE_EVALMESH2;
  1015.       n[1].e = mode;
  1016.       n[2].i = i1;
  1017.       n[3].i = i2;
  1018.       n[4].i = j1;
  1019.       n[5].i = j2;
  1020.    }
  1021. }
  1022.  
  1023.  
  1024. void gl_save_evalpoint1( GLint i )
  1025. {
  1026.    Node *n = alloc_nodes(2);
  1027.    if (n) {
  1028.       n[0].kind = NODE_EVALPOINT1;
  1029.       n[1].i = i;
  1030.    }
  1031. }
  1032.  
  1033.  
  1034. void gl_save_evalpoint2( GLint i, GLint j )
  1035. {
  1036.    Node *n = alloc_nodes(3);
  1037.    if (n) {
  1038.       n[0].kind = NODE_EVALPOINT2;
  1039.       n[1].i = i;
  1040.       n[2].i = j;
  1041.    }
  1042. }
  1043.  
  1044.  
  1045. void gl_save_fog( GLenum pname, const GLfloat *params )
  1046. {
  1047.    Node *n = alloc_nodes(6);
  1048.    if (n) {
  1049.       n[0].kind = NODE_FOG;
  1050.       n[1].e = pname;
  1051.       n[2].f = params[0];
  1052.       n[3].f = params[1];
  1053.       n[4].f = params[2];
  1054.       n[5].f = params[3];
  1055.    }
  1056. }
  1057.  
  1058.  
  1059. void gl_save_frontface( GLenum mode )
  1060. {
  1061.    Node *n = alloc_nodes(2);
  1062.    if (n) {
  1063.       n[0].kind = NODE_FRONT_FACE;
  1064.       n[1].e = mode;
  1065.    }
  1066. }
  1067.  
  1068.  
  1069. void gl_save_hint( GLenum target, GLenum mode )
  1070. {
  1071.    Node *n = alloc_nodes(3);
  1072.    if (n) {
  1073.       n[0].kind = NODE_INDEX;
  1074.       n[1].e = target;
  1075.       n[2].e = mode;
  1076.    }
  1077. }
  1078.  
  1079.  
  1080. /*
  1081.  * Compile a glIndex call into current display list.
  1082.  */
  1083. void gl_save_index( GLuint index )
  1084. {
  1085.    Node *n = alloc_nodes(2);
  1086.    if (n) {
  1087.       n[0].kind = NODE_INDEX;
  1088.       n[1].ui = index;
  1089.    }
  1090. }
  1091.  
  1092.  
  1093. void gl_save_indexmask( GLuint mask )
  1094. {
  1095.    Node *n = alloc_nodes(2);
  1096.    if (n) {
  1097.       n[0].kind = NODE_INDEX_MASK;
  1098.       n[1].ui = mask;
  1099.    }
  1100. }
  1101.  
  1102.  
  1103.  
  1104. void gl_save_initnames( void )
  1105. {
  1106.    Node *n = alloc_nodes(1);
  1107.    if (n) {
  1108.       n[0].kind = NODE_INIT_NAMES;
  1109.    }
  1110. }
  1111.  
  1112.       
  1113. /*
  1114.  * save a glLight* call.
  1115.  */
  1116. void gl_save_light( GLenum light, GLenum pname, const GLfloat *params,
  1117.             GLuint numparams )
  1118. {
  1119.    Node *n = alloc_nodes(7);
  1120.    if (n) {
  1121.       GLuint i;
  1122.       n[0].kind = NODE_LIGHT;
  1123.       n[1].e = light;
  1124.       n[2].e = pname;
  1125.       for (i=0;i<numparams;i++) {
  1126.      n[3+i].f = params[i];
  1127.       }
  1128.    }
  1129. }
  1130.  
  1131.  
  1132. void gl_save_lightmodel( GLenum pname, const GLfloat *params )
  1133. {
  1134.    Node *n = alloc_nodes(6);
  1135.    if (n) {
  1136.       n[0].kind = NODE_LIGHT_MODEL;
  1137.       n[1].e = pname;
  1138.       n[2].f = params[0];
  1139.       n[3].f = params[1];
  1140.       n[4].f = params[2];
  1141.       n[5].f = params[3];
  1142.    }
  1143. }
  1144.  
  1145.  
  1146.  
  1147. /*
  1148.  * Save a glLineStipple call.
  1149.  */
  1150. void gl_save_linestipple( GLint factor, GLushort pattern )
  1151. {
  1152.    Node *n = alloc_nodes(3);
  1153.    if (n) {
  1154.       n[0].kind = NODE_LINE_STIPPLE;
  1155.       n[1].i = factor;
  1156.       n[2].us = pattern;
  1157.    }
  1158. }
  1159.  
  1160.  
  1161. /*
  1162.  * Save a glLineWidth call.
  1163.  */
  1164. void gl_save_linewidth( GLfloat width )
  1165. {
  1166.    Node *n = alloc_nodes(2);
  1167.    if (n) {
  1168.       n[0].kind = NODE_LINE_WIDTH;
  1169.       n[1].f = width;
  1170.    }
  1171. }
  1172.  
  1173.  
  1174. /*
  1175.  * Save a glListBase call.
  1176.  */
  1177. void gl_save_listbase( GLuint base )
  1178. {
  1179.    Node *n = alloc_nodes(2);
  1180.    if (n) {
  1181.       n[0].kind = NODE_LIST_BASE;
  1182.       n[1].ui = base;
  1183.    }
  1184. }
  1185.  
  1186.  
  1187. /*
  1188.  * Add a load matrix operation to current display list.
  1189.  */
  1190. void gl_save_loadmatrix( const GLfloat *m )
  1191. {
  1192.    Node *n = alloc_nodes(17);
  1193.    if (n) {
  1194.       GLuint i;
  1195.       n[0].kind = NODE_LOAD_MATRIX;
  1196.       for (i=0;i<16;i++) {
  1197.      n[1+i].f = m[i];
  1198.       }
  1199.    }
  1200. }
  1201.  
  1202.  
  1203. /*
  1204.  * Add a glLoadName to the current display list.
  1205.  */
  1206. void gl_save_loadname( GLuint name )
  1207. {
  1208.    Node *n = alloc_nodes(2);
  1209.    if (n) {
  1210.       n[0].kind = NODE_LOAD_NAME;
  1211.       n[1].ui = name;
  1212.    }
  1213. }
  1214.  
  1215.  
  1216. /*
  1217.  * Save a glLogicOp call.
  1218.  */
  1219. void gl_save_logicop( GLenum opcode )
  1220. {
  1221.    Node *n = alloc_nodes(2);
  1222.    if (n) {
  1223.       n[0].kind = NODE_LOGIC_OP;
  1224.       n[1].e = opcode;
  1225.    }
  1226. }
  1227.  
  1228.  
  1229.  
  1230. void gl_save_map1( GLenum target, GLfloat u1, GLfloat u2, GLint stride,
  1231.            GLint order, const GLfloat *points )
  1232. {
  1233.    Node *n = alloc_nodes(7);
  1234.    if (n) {
  1235.       n[0].kind = NODE_MAP1;
  1236.       n[1].e = target;
  1237.       n[2].f = u1;
  1238.       n[3].f = u2;
  1239.       n[4].i = stride;
  1240.       n[5].i = order;
  1241.       n[6].data = (void *) points;
  1242.    }
  1243. }
  1244.  
  1245.  
  1246.  
  1247. void gl_save_map2( GLenum target,
  1248.            GLfloat u1, GLfloat u2, GLint ustride, GLint uorder,
  1249.            GLfloat v1, GLfloat v2, GLint vstride, GLint vorder,
  1250.            const GLfloat *points )
  1251. {
  1252.    Node *n = alloc_nodes(11);
  1253.    if (n) {
  1254.       n[0].kind = NODE_MAP2;
  1255.       n[1].e = target;
  1256.       n[2].f = u1;
  1257.       n[3].f = u2;
  1258.       n[4].f = v1;
  1259.       n[5].f = v2;
  1260.       n[6].i = ustride;
  1261.       n[7].i = vstride;
  1262.       n[8].i = uorder;
  1263.       n[9].i = vorder;
  1264.       n[10].data = (void *) points;
  1265.    }
  1266. }
  1267.  
  1268.  
  1269.  
  1270. void gl_save_mapgrid1( GLint un, GLfloat u1, GLfloat u2 )
  1271. {
  1272.    Node *n = alloc_nodes(4);
  1273.    if (n) {
  1274.       n[0].kind = NODE_MAPGRID1;
  1275.       n[1].i = un;
  1276.       n[2].f = u1;
  1277.       n[3].f = u2;
  1278.    }
  1279. }
  1280.  
  1281.  
  1282. void gl_save_mapgrid2( GLint un, GLfloat u1, GLfloat u2,
  1283.                GLint vn, GLfloat v1, GLfloat v2 )
  1284. {
  1285.    Node *n = alloc_nodes(7);
  1286.    if (n) {
  1287.       n[0].kind = NODE_MAPGRID2;
  1288.       n[1].i = un;
  1289.       n[2].f = u1;
  1290.       n[3].f = u2;
  1291.       n[4].i = vn;
  1292.       n[5].f = v1;
  1293.       n[6].f = v2;
  1294.    }
  1295. }
  1296.  
  1297.  
  1298.  
  1299. /*
  1300.  * Add a glMaterial call to current display list.
  1301.  */
  1302. void gl_save_material( GLenum face, GLenum pname, const GLfloat *params )
  1303. {
  1304.    Node *n = alloc_nodes(7);
  1305.    if (n) {
  1306.       n[0].kind = NODE_MATERIAL;
  1307.       n[1].e = face;
  1308.       n[2].e = pname;
  1309.       n[3].f = params[0];
  1310.       n[4].f = params[1];
  1311.       n[5].f = params[2];
  1312.       n[6].f = params[3];
  1313.    }
  1314. }
  1315.  
  1316.  
  1317.  
  1318. /*
  1319.  * Add a mult matrix operation to current display list.
  1320.  */
  1321. void gl_save_multmatrix( const GLfloat *m )
  1322. {
  1323.    Node *n = alloc_nodes(17);
  1324.    if (n) {
  1325.       GLuint i;
  1326.       n[0].kind = NODE_MULT_MATRIX;
  1327.       for (i=0;i<16;i++) {
  1328.      n[1+i].f = m[i];
  1329.       }
  1330.    }
  1331. }
  1332.  
  1333.  
  1334.  
  1335. /*
  1336.  * Add a normal to current display list.
  1337.  */
  1338. void gl_save_normal3fv( const GLfloat norm[3] )
  1339. {
  1340.    Node *n = alloc_nodes(4);
  1341.    if (n) {
  1342.       n[0].kind = NODE_NORMAL;
  1343.       n[1].f = norm[0];
  1344.       n[2].f = norm[1];
  1345.       n[3].f = norm[2];
  1346.    }
  1347. }
  1348.  
  1349.  
  1350.  
  1351. /*
  1352.  * Add a normal to current display list.
  1353.  */
  1354. void gl_save_normal3f( GLfloat nx, GLfloat ny, GLfloat nz )
  1355. {
  1356.    Node *n = alloc_nodes(4);
  1357.    if (n) {
  1358.       n[0].kind = NODE_NORMAL;
  1359.       n[1].f = nx;
  1360.       n[2].f = ny;
  1361.       n[3].f = nz;
  1362.    }
  1363. }
  1364.  
  1365.  
  1366.  
  1367. /*
  1368.  * Save a glPixelMap call.
  1369.  */
  1370. void gl_save_pixelmap( GLenum map, GLint mapsize, const GLfloat *values )
  1371. {
  1372.    Node *n = alloc_nodes(4);
  1373.    if (n) {
  1374.       n[0].kind = NODE_PIXEL_MAP;
  1375.       n[1].e = map;
  1376.       n[2].i = mapsize;
  1377.       n[3].data  = (void *) malloc( mapsize * sizeof(GLfloat) );
  1378.       MEMCPY( n[3].data, (void *) values, mapsize * sizeof(GLfloat) );
  1379.    }
  1380. }
  1381.  
  1382.  
  1383.  
  1384. /*
  1385.  * Save a glPixelZoom call.
  1386.  */
  1387. void gl_save_pixelzoom( GLfloat xfactor, GLfloat yfactor )
  1388. {
  1389.    Node *n = alloc_nodes(4);
  1390.    if (n) {
  1391.       n[0].kind = NODE_PIXEL_ZOOM;
  1392.       n[1].f = xfactor;
  1393.       n[2].f = yfactor;
  1394.    }
  1395. }
  1396.  
  1397.  
  1398.  
  1399. /*
  1400.  * Save a glPointSize call.
  1401.  */
  1402. void gl_save_pointsize( GLfloat size )
  1403. {
  1404.    Node *n = alloc_nodes(2);
  1405.    if (n) {
  1406.       n[0].kind = NODE_POINTSIZE;
  1407.       n[1].f = size;
  1408.    }
  1409. }
  1410.  
  1411.  
  1412.  
  1413. /*
  1414.  * Save a glPolygonMode call.
  1415.  */
  1416. void gl_save_polygonmode( GLenum face, GLenum mode )
  1417. {
  1418.    Node *n = alloc_nodes(3);
  1419.    if (n) {
  1420.       n[0].kind = NODE_POLYGON_MODE;
  1421.       n[1].e = face;
  1422.       n[2].e = mode;
  1423.    }
  1424. }
  1425.  
  1426.  
  1427.  
  1428. void gl_save_polygonoffset( GLfloat factor, GLfloat bias )
  1429. {
  1430.    Node *n = alloc_nodes(3);
  1431.    if (n) {
  1432.       n[0].kind = NODE_POLYGON_OFFSET;
  1433.       n[1].f = factor;
  1434.       n[2].f = bias;
  1435.    }
  1436. }
  1437.  
  1438.  
  1439. /*
  1440.  * Add a pop attributies operation to current display list.
  1441.  */
  1442. void gl_save_popattrib( void )
  1443. {
  1444.    Node *n = alloc_nodes(1);
  1445.    if (n) {
  1446.       n[0].kind = NODE_POP_ATTRIB;
  1447.    }
  1448. }
  1449.  
  1450.  
  1451. /*
  1452.  * Add a pop matrix operation to current display list.
  1453.  */
  1454. void gl_save_popmatrix( void )
  1455. {
  1456.    Node *n = alloc_nodes(1);
  1457.    if (n) {
  1458.       n[0].kind = NODE_POP_MATRIX;
  1459.    }
  1460. }
  1461.  
  1462.  
  1463. /*
  1464.  * Add a glPopName to the current display list.
  1465.  */
  1466. void gl_save_popname( void )
  1467. {
  1468.    Node *n = alloc_nodes(1);
  1469.    if (n) {
  1470.       n[0].kind = NODE_POP_NAME;
  1471.    }
  1472. }
  1473.  
  1474.  
  1475.  
  1476. /*
  1477.  * Add a push attributies operation to current display list.
  1478.  */
  1479. void gl_save_pushattrib( GLbitfield mask )
  1480. {
  1481.    Node *n = alloc_nodes(2);
  1482.    if (n) {
  1483.       n[0].kind = NODE_PUSH_ATTRIB;
  1484.       n[1].bf = mask;
  1485.    }
  1486. }
  1487.  
  1488.  
  1489.  
  1490. /*
  1491.  * Add a push matrix operation to current display list.
  1492.  */
  1493. void gl_save_pushmatrix( void )
  1494. {
  1495.    Node *n = alloc_nodes(1);
  1496.    if (n) {
  1497.       n[0].kind = NODE_PUSH_MATRIX;
  1498.    }
  1499. }
  1500.  
  1501.  
  1502. /*
  1503.  * Add a glPushName to the current display list.
  1504.  */
  1505. void gl_save_pushname( GLuint name )
  1506. {
  1507.    Node *n = alloc_nodes(2);
  1508.    if (n) {
  1509.       n[0].kind = NODE_PUSH_NAME;
  1510.       n[1].ui = name;
  1511.    }
  1512. }
  1513.  
  1514.  
  1515. void gl_save_rasterpos( const GLfloat v[4] )
  1516. {
  1517.    Node *n = alloc_nodes(5);
  1518.    if (n) {
  1519.       n[0].kind = NODE_RASTER_POS;
  1520.       n[1].f = v[0];
  1521.       n[2].f = v[1];
  1522.       n[3].f = v[2];
  1523.       n[4].f = v[3];
  1524.    }
  1525. }
  1526.  
  1527.  
  1528.  
  1529. void gl_save_passthrough( GLfloat token )
  1530. {
  1531.    Node *n = alloc_nodes(2);
  1532.    if (n) {
  1533.       n[0].kind = NODE_PASSTHROUGH;
  1534.       n[1].f = token;
  1535.    }
  1536. }
  1537.  
  1538.  
  1539.  
  1540. void gl_save_readbuffer( GLenum mode )
  1541. {
  1542.    Node *n = alloc_nodes(2);
  1543.    if (n) {
  1544.       n[0].kind = NODE_READ_BUFFER;
  1545.       n[1].e = mode;
  1546.    }
  1547. }
  1548.  
  1549.  
  1550. void gl_save_scissor( GLint x, GLint y, GLsizei width, GLsizei height )
  1551. {
  1552.    Node *n = alloc_nodes(5);
  1553.    if (n) {
  1554.       n[0].kind = NODE_SCISSOR;
  1555.       n[1].i = x;
  1556.       n[2].i = y;
  1557.       n[3].i = width;
  1558.       n[4].i = height;
  1559.    }
  1560. }
  1561.  
  1562.  
  1563.  
  1564. /*
  1565.  * Save a "set boolean value" operation.
  1566.  */
  1567. void gl_save_set_boolean( GLboolean *ptr, GLboolean value )
  1568. {
  1569.    Node *n = alloc_nodes(3);
  1570.    if (n) {
  1571.       n[0].kind = NODE_SET_BOOLEAN;
  1572.       n[1].data = (void *) ptr;
  1573.       n[2].b = value;
  1574.    }
  1575. }
  1576.  
  1577.  
  1578.  
  1579. /*
  1580.  * Save a "set enum value" operation.
  1581.  */
  1582. void gl_save_set_enum( GLenum *ptr, GLenum value )
  1583. {
  1584.    Node *n = alloc_nodes(3);
  1585.    if (n) {
  1586.       n[0].kind = NODE_SET_ENUM;
  1587.       n[1].data = (void *) ptr;
  1588.       n[2].e = value;
  1589.    }
  1590. }
  1591.  
  1592.  
  1593.  
  1594. /*
  1595.  * Save a "set float value" operation.
  1596.  */
  1597. void gl_save_set_float( GLfloat *ptr, GLfloat value )
  1598. {
  1599.    Node *n = alloc_nodes(3);
  1600.    if (n) {
  1601.       n[0].kind = NODE_SET_FLOAT;
  1602.       n[1].data = (void *) ptr;
  1603.       n[2].f = value;
  1604.    }
  1605. }
  1606.  
  1607.  
  1608.  
  1609. /*
  1610.  * Save a "set int value" operation.
  1611.  */
  1612. void gl_save_set_int( GLint *ptr, GLint value )
  1613. {
  1614.    Node *n = alloc_nodes(3);
  1615.    if (n) {
  1616.       n[0].kind = NODE_SET_INT;
  1617.       n[1].data = (void *) ptr;
  1618.       n[2].i = value;
  1619.    }
  1620. }
  1621.  
  1622.  
  1623.  
  1624. /*
  1625.  * Save a "set uint value" operation.
  1626.  */
  1627. void gl_save_set_uint( GLuint *ptr, GLuint value )
  1628. {
  1629.    Node *n = alloc_nodes(3);
  1630.    if (n) {
  1631.       n[0].kind = NODE_SET_UINT;
  1632.       n[1].data = (void *) ptr;
  1633.       n[2].ui = value;
  1634.    }
  1635. }
  1636.  
  1637.  
  1638.  
  1639. /*
  1640.  * Add a glShadeModel call to current display list.
  1641.  */
  1642. void gl_save_shademodel( GLenum mode )
  1643. {
  1644.    Node *n = alloc_nodes(2);
  1645.    if (n) {
  1646.       n[0].kind = NODE_SHADE_MODEL;
  1647.       n[1].e = mode;
  1648.    }
  1649. }
  1650.  
  1651.  
  1652.  
  1653. void gl_save_stencilfunc( GLenum func, GLint ref, GLuint mask )
  1654. {
  1655.    Node *n = alloc_nodes(4);
  1656.    if (n) {
  1657.       n[0].kind = NODE_STENCIL_FUNC;
  1658.       n[1].e = func;
  1659.       n[2].i = ref;
  1660.       n[3].ui = mask;
  1661.    }
  1662. }
  1663.  
  1664.  
  1665.  
  1666. void gl_save_stencilmask( GLuint mask )
  1667. {
  1668.    Node *n = alloc_nodes(2);
  1669.    if (n) {
  1670.       n[0].kind = NODE_STENCIL_MASK;
  1671.       n[1].ui = mask;
  1672.    }
  1673. }
  1674.  
  1675.  
  1676.  
  1677. void gl_save_stencilop( GLenum fail, GLenum zfail, GLenum zpass )
  1678. {
  1679.    Node *n = alloc_nodes(4);
  1680.    if (n) {
  1681.       n[0].kind = NODE_STENCIL_OP;
  1682.       n[1].e = fail;
  1683.       n[2].e = zfail;
  1684.       n[3].e = zpass;
  1685.    }
  1686. }
  1687.  
  1688.  
  1689.  
  1690.  
  1691. /*
  1692.  * Add a texture coordinate to current display list.
  1693.  */
  1694. void gl_save_texcoord( const GLfloat tc[4] )
  1695. {
  1696.    Node *n = alloc_nodes(5);
  1697.    if (n) {
  1698.       n[0].kind = NODE_TEXCOORD;
  1699.       n[1].f = tc[0];
  1700.       n[2].f = tc[1];
  1701.       n[3].f = tc[2];
  1702.       n[4].f = tc[3];
  1703.    }
  1704. }
  1705.  
  1706.  
  1707.  
  1708. void gl_save_texenv( GLenum target, GLenum pname, const GLfloat *params )
  1709. {
  1710.    Node *n = alloc_nodes(7);
  1711.    if (n) {
  1712.       n[0].kind = NODE_TEXENV;
  1713.       n[1].e = target;
  1714.       n[2].e = pname;
  1715.       n[3].f = params[0];
  1716.       n[4].f = params[1];
  1717.       n[5].f = params[2];
  1718.       n[6].f = params[3];
  1719.    }
  1720. }
  1721.  
  1722.  
  1723. void gl_save_texgen( GLenum coord, GLenum pname, const GLfloat *params )
  1724. {
  1725.    Node *n = alloc_nodes(7);
  1726.    if (n) {
  1727.       n[0].kind = NODE_TEXGEN;
  1728.       n[1].e = coord;
  1729.       n[2].e = pname;
  1730.       n[3].f = params[0];
  1731.       n[4].f = params[1];
  1732.       n[5].f = params[2];
  1733.       n[6].f = params[3];
  1734.    }
  1735. }
  1736.  
  1737.  
  1738. void gl_save_texparameter( GLenum target, GLenum pname, const GLfloat *params )
  1739. {
  1740.    Node *n = alloc_nodes(7);
  1741.    if (n) {
  1742.       n[0].kind = NODE_TEXPARAMETER;
  1743.       n[1].e = target;
  1744.       n[2].e = pname;
  1745.       n[3].f = params[0];
  1746.       n[4].f = params[1];
  1747.       n[5].f = params[2];
  1748.       n[6].f = params[3];
  1749.    }
  1750. }
  1751.  
  1752.  
  1753.  
  1754. /*
  1755.  * Add a glTexImage1D call to current display list.
  1756.  */
  1757. void gl_save_teximage1d( GLint level, GLint components,
  1758.              GLsizei width, GLint border,
  1759.              const GLubyte *pixels )
  1760. {
  1761.    Node *n = alloc_nodes(6);
  1762.    if (n) {
  1763.       n[0].kind = NODE_TEXIMAGE1D;
  1764.       n[1].i = level;
  1765.       n[2].i = components;
  1766.       n[3].i = (GLint) width;
  1767.       n[4].i = border;
  1768.       n[5].data = (GLvoid *) pixels;
  1769.    }
  1770. }
  1771.  
  1772.  
  1773.  
  1774. /*
  1775.  * Add a glTexImage2D call to current display list.
  1776.  */
  1777. void gl_save_teximage2d( GLint level, GLint components,
  1778.              GLsizei width, GLsizei height, GLint border,
  1779.              const GLubyte *pixels )
  1780. {
  1781.    Node *n = alloc_nodes(7);
  1782.    if (n) {
  1783.       n[0].kind = NODE_TEXIMAGE2D;
  1784.       n[1].i = level;
  1785.       n[2].i = components;
  1786.       n[3].i = (GLint) width;
  1787.       n[4].i = (GLint) height;
  1788.       n[5].i = border;
  1789.       n[6].data = (GLvoid *) pixels;
  1790.    }
  1791. }
  1792.  
  1793.  
  1794.  
  1795. /*
  1796.  * Add a vertex to current display list.
  1797.  */
  1798. void gl_save_vertex( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
  1799. {
  1800.    Node *n = alloc_nodes( 5 );
  1801.    if (n) {
  1802.       n[0].kind = NODE_VERTEX;
  1803.       n[1].f = x;
  1804.       n[2].f = y;
  1805.       n[3].f = z;
  1806.       n[4].f = w;
  1807.    }
  1808. }
  1809.  
  1810.  
  1811.  
  1812. /*
  1813.  * Save a glViewport call to display list.
  1814.  */
  1815. void gl_save_viewport( GLint x, GLint y, GLsizei width, GLsizei height )
  1816. {
  1817.    Node *n = alloc_nodes( 5 );
  1818.    if (n) {
  1819.       n[0].kind = NODE_VIEWPORT;
  1820.       n[1].i = x;
  1821.       n[2].i = y;
  1822.       n[3].i = (GLint) width;
  1823.       n[4].i = (GLint) height;
  1824.    }
  1825. }
  1826.  
  1827.  
  1828.  
  1829. /*
  1830.  * Compile a glCallList call into current display list.
  1831.  */
  1832. static void gl_save_call( GLuint list )
  1833. {
  1834.    Node *n = alloc_nodes(2);
  1835.    if (n) {
  1836.       n[0].kind = NODE_CALL_LIST;
  1837.       n[1].ui = list;
  1838.    }
  1839. }
  1840.  
  1841.  
  1842.  
  1843. /*
  1844.  * Compile a glCallLists call into current display list.  The difference
  1845.  * between this and the above function is that the ListBase value will
  1846.  * be added to the display list number before executing.
  1847.  */
  1848. static void gl_save_call_offset( GLuint list )
  1849. {
  1850.    Node *n = alloc_nodes(2);
  1851.    if (n) {
  1852.       n[0].kind = NODE_CALL_LIST_OFFSET;
  1853.       n[1].ui = list;
  1854.    }
  1855. }
  1856.  
  1857.  
  1858.  
  1859.  
  1860. /**********************************************************************/
  1861. /*                     Display list execution                         */
  1862. /**********************************************************************/
  1863.  
  1864.  
  1865. /*
  1866.  * Execute a display list.  Note that the ListBase offset must have already
  1867.  * been added before calling this function.  I.e. the list argument is
  1868.  * the absolute list number, not relative to ListBase.
  1869.  * Input:  list - list number in [1..]
  1870.  */
  1871. static void execute_list( GLuint list )
  1872. {
  1873.    Node *n;
  1874.    GLboolean done;
  1875.    Kind k;
  1876.  
  1877.    if (!glIsList(list))
  1878.       return;
  1879.  
  1880.    CC.CallDepth++;
  1881.  
  1882.    n = CC.ListGroup->List[list-1];
  1883.    done = GL_FALSE;
  1884.    while (!done) {
  1885.       k = n[0].kind;
  1886.  
  1887.       switch (k) {
  1888.      /* Frequently called functions: */
  1889.          case NODE_VERTEX:
  1890.         gl_execute_vertex( n[1].f, n[2].f, n[3].f, n[4].f );
  1891.             break;
  1892.          case NODE_NORMAL:
  1893.             CC.Current.Normal[0] = n[1].f;
  1894.             CC.Current.Normal[1] = n[2].f;
  1895.             CC.Current.Normal[2] = n[3].f;
  1896.             break;
  1897.      case NODE_COLOR:
  1898.         if (sizeof(Node)==sizeof(GLfloat)) {
  1899.            gl_color( &n[1].f );
  1900.         }
  1901.         else {
  1902.            GLfloat c[4];
  1903.            c[0] = n[1].f;
  1904.            c[1] = n[2].f;
  1905.            c[2] = n[3].f;
  1906.            c[3] = n[4].f;
  1907.            gl_color( c );
  1908.         }
  1909.         break;
  1910.          case NODE_INDEX:
  1911.         gl_index( n[1].ui );
  1912.             break;
  1913.          case NODE_BEGIN:
  1914.             gl_begin( n[1].e );
  1915.             break;
  1916.          case NODE_END:
  1917.             gl_end();
  1918.             break;
  1919.      case NODE_TEXCOORD:
  1920.         CC.Current.TexCoord[0] = n[1].f;
  1921.         CC.Current.TexCoord[1] = n[2].f;
  1922.         CC.Current.TexCoord[2] = n[3].f;
  1923.         CC.Current.TexCoord[3] = n[4].f;
  1924.         break;
  1925.  
  1926.      /* Everything Else: */
  1927.          case NODE_ACCUM:
  1928.         gl_accum( n[1].e, n[2].f );
  1929.         break;
  1930.          case NODE_ALPHA_FUNC:
  1931.         glAlphaFunc( n[1].e, n[2].f );
  1932.         break;
  1933.      case NODE_BITMAP:
  1934.         gl_bitmap( (GLsizei) n[1].i, (GLsizei) n[2].i,
  1935.                n[3].f, n[4].f,
  1936.                n[5].f, n[6].f,
  1937.                (GLubyte *) n[7].data );
  1938.         break;
  1939.      case NODE_BLEND_FUNC:
  1940.         glBlendFunc( n[1].e, n[2].e );
  1941.         break;
  1942.          case NODE_CALL_LIST:
  1943.         /* Generated by glCallList(), don't add ListBase */
  1944.             if (CC.CallDepth<MAX_LIST_NESTING) {
  1945.                execute_list( n[1].ui );
  1946.             }
  1947.             break;
  1948.          case NODE_CALL_LIST_OFFSET:
  1949.         /* Generated by glCallLists() so we must add ListBase */
  1950.             if (CC.CallDepth<MAX_LIST_NESTING) {
  1951.                execute_list( CC.List.ListBase + n[1].ui );
  1952.             }
  1953.             break;
  1954.      case NODE_CLEAR:
  1955.         glClear( n[1].bf );
  1956.         break;
  1957.      case NODE_CLEAR_COLOR:
  1958.         glClearColor( n[1].f, n[2].f, n[3].f, n[4].f );
  1959.         break;
  1960.      case NODE_CLEAR_ACCUM:
  1961.         glClearAccum( n[1].f, n[2].f, n[3].f, n[4].f );
  1962.         break;
  1963.      case NODE_CLEAR_DEPTH:
  1964.         glClearDepth( (GLclampd) n[1].f );
  1965.         break;
  1966.      case NODE_CLEAR_INDEX:
  1967.         glClearIndex( n[1].ui );
  1968.         break;
  1969.      case NODE_CLEAR_STENCIL:
  1970.         glClearStencil( n[1].i );
  1971.         break;
  1972.          case NODE_CLIP_PLANE:
  1973.             {
  1974.                GLfloat equ[4];
  1975.                equ[0] = n[2].f;
  1976.                equ[1] = n[3].f;
  1977.                equ[2] = n[4].f;
  1978.                equ[3] = n[5].f;
  1979.                gl_clipplane( n[1].e, equ );
  1980.             }
  1981.             break;
  1982.      case NODE_COLOR_MASK:
  1983.         glColorMask( n[1].b, n[2].b, n[3].b, n[4].b );
  1984.         break;
  1985.      case NODE_COPY_PIXELS:
  1986.         gl_copypixels( n[1].i, n[2].i,
  1987.                (GLsizei) n[3].i, (GLsizei) n[4].i, n[5].e );
  1988.         break;
  1989.      case NODE_CULL_FACE:
  1990.         glCullFace( n[1].e );
  1991.         break;
  1992.      case NODE_DEPTH_FUNC:
  1993.         glDepthFunc( n[1].e );
  1994.         break;
  1995.      case NODE_DEPTH_MASK:
  1996.         glDepthMask( n[1].b );
  1997.         break;
  1998.      case NODE_DEPTH_RANGE:
  1999.         glDepthRange( (GLclampd) n[1].f, (GLclampd) n[2].f );
  2000.         break;
  2001.      case NODE_DISABLE:
  2002.         gl_enable( n[1].e, GL_FALSE );
  2003.         break;
  2004.      case NODE_DRAW_BUFFER:
  2005.         glDrawBuffer( n[1].e );
  2006.         break;
  2007.      case NODE_DRAW_PIXELS:
  2008.         gl_drawpixels( (GLsizei) n[1].i, (GLsizei) n[2].i,
  2009.                n[3].e, n[4].e, n[5].data );
  2010.         break;
  2011.      case NODE_ENABLE:
  2012.         gl_enable( n[1].e, GL_TRUE );
  2013.         break;
  2014.      case NODE_EVALCOORD1:
  2015.         gl_evalcoord1( n[1].f );
  2016.         break;
  2017.      case NODE_EVALCOORD2:
  2018.         gl_evalcoord2( n[1].f, n[2].f );
  2019.         break;
  2020.      case NODE_EVALMESH1:
  2021.         glEvalMesh1( n[1].e, n[2].i, n[3].i );
  2022.         break;
  2023.      case NODE_EVALMESH2:
  2024.         glEvalMesh2( n[1].e, n[2].i, n[3].i, n[4].i, n[5].i );
  2025.         break;
  2026.      case NODE_EVALPOINT1:
  2027.         glEvalPoint1( n[1].i );
  2028.         break;
  2029.      case NODE_EVALPOINT2:
  2030.         glEvalPoint2( n[1].i, n[2].i );
  2031.         break;
  2032.      case NODE_FOG:
  2033.         {
  2034.            GLfloat p[4];
  2035.            p[0] = n[2].f;
  2036.            p[1] = n[3].f;
  2037.            p[2] = n[4].f;
  2038.            p[3] = n[5].f;
  2039.            gl_fog( n[1].e, p );
  2040.         }
  2041.         break;
  2042.      case NODE_FRONT_FACE:
  2043.         glFrontFace( n[1].e );
  2044.         break;
  2045.      case NODE_HINT:
  2046.         glHint( n[1].e, n[2].e );
  2047.         break;
  2048.      case NODE_INDEX_MASK:
  2049.         glIndexMask( n[1].ui );
  2050.         break;
  2051.      case NODE_INIT_NAMES:
  2052.         glInitNames();
  2053.         break;
  2054.          case NODE_LIGHT:
  2055.         {
  2056.            GLfloat p[4];
  2057.            p[0] = n[3].f;
  2058.            p[1] = n[4].f;
  2059.            p[2] = n[5].f;
  2060.            p[3] = n[6].f;
  2061.            gl_light( n[1].e, n[2].e, p );
  2062.         }
  2063.         break;
  2064.          case NODE_LIGHT_MODEL:
  2065.         {
  2066.            GLfloat p[4];
  2067.            p[0] = n[2].f;
  2068.            p[1] = n[3].f;
  2069.            p[2] = n[4].f;
  2070.            p[3] = n[5].f;
  2071.            gl_lightmodel( n[1].e, p );
  2072.         }
  2073.         break;
  2074.      case NODE_LINE_STIPPLE:
  2075.         glLineStipple( n[1].i, n[2].us );
  2076.         break;
  2077.      case NODE_LINE_WIDTH:
  2078.         glLineWidth( n[1].f );
  2079.         break;
  2080.      case NODE_LIST_BASE:
  2081.         glListBase( n[1].ui );
  2082.         break;
  2083.      case NODE_LOAD_MATRIX:
  2084.         if (sizeof(Node)==sizeof(GLfloat)) {
  2085.            gl_load_matrix( &n[1].f );
  2086.         }
  2087.         else {
  2088.            GLfloat m[16];
  2089.            GLuint i;
  2090.            for (i=0;i<16;i++) {
  2091.           m[i] = n[1+i].f;
  2092.            }
  2093.            gl_load_matrix( m );
  2094.         }
  2095.         break;
  2096.      case NODE_LOAD_NAME:
  2097.         glLoadName( n[1].ui );
  2098.         break;
  2099.      case NODE_LOGIC_OP:
  2100.         gl_logicop( n[1].e );
  2101.         break;
  2102.      case NODE_MAP1:
  2103.         gl_map1( n[1].e, n[2].f, n[3].f,
  2104.              n[4].i, n[5].i, (GLfloat *) n[6].data );
  2105.         break;
  2106.      case NODE_MAP2:
  2107.         gl_map2( n[1].e,
  2108.              n[2].f, n[3].f,  /* u1, u2 */
  2109.              n[6].i, n[8].i,  /* ustride, uorder */
  2110.              n[4].f, n[5].f,  /* v1, v2 */
  2111.              n[7].i, n[9].i,  /* vstride, vorder */
  2112.              (GLfloat *) n[10].data );
  2113.         break;
  2114.      case NODE_MAPGRID1:
  2115.         gl_mapgrid1( n[1].i, n[2].f, n[3].f );
  2116.         break;
  2117.      case NODE_MAPGRID2:
  2118.         gl_mapgrid2( n[1].i, n[2].f, n[3].f, n[4].i, n[5].f, n[6].f );
  2119.         break;
  2120.      case NODE_MATERIAL:
  2121.         {
  2122.            GLfloat params[4];
  2123.            params[0] = n[3].f;
  2124.            params[1] = n[4].f;
  2125.            params[2] = n[5].f;
  2126.            params[3] = n[6].f;
  2127.            gl_material( n[1].e, n[2].e, params );
  2128.         }
  2129.         break;
  2130.      case NODE_MULT_MATRIX:
  2131.         if (sizeof(Node)==sizeof(GLfloat)) {
  2132.            gl_mult_matrix( &n[1].f );
  2133.         }
  2134.         else {
  2135.            GLfloat m[16];
  2136.            GLuint i;
  2137.            for (i=0;i<16;i++) {
  2138.           m[i] = n[1+i].f;
  2139.            }
  2140.            gl_mult_matrix( m );
  2141.         }
  2142.         break;
  2143.      case NODE_PASSTHROUGH:
  2144.         gl_passthrough( n[1].f );
  2145.         break;
  2146.      case NODE_PIXEL_MAP:
  2147.         gl_pixel_map( n[1].e, n[2].i, (GLfloat *) n[3].data );
  2148.         break;
  2149.      case NODE_PIXEL_ZOOM:
  2150.         glPixelZoom( n[1].f, n[2].f );
  2151.         break;
  2152.      case NODE_POINTSIZE:
  2153.         glPointSize( n[1].f );
  2154.         break;
  2155.      case NODE_POLYGON_MODE:
  2156.         glPolygonMode( n[1].e, n[2].e );
  2157.         break;
  2158.      case NODE_POLYGON_OFFSET:
  2159.         glPolygonOffsetEXT( n[1].f, n[2].f );
  2160.         break;
  2161.      case NODE_POP_ATTRIB:
  2162.         gl_pop_attrib();
  2163.         break;
  2164.      case NODE_POP_MATRIX:
  2165.         glPopMatrix();
  2166.         break;
  2167.      case NODE_POP_NAME:
  2168.         glPopName();
  2169.         break;
  2170.      case NODE_PUSH_ATTRIB:
  2171.         gl_push_attrib( n[1].bf );
  2172.         break;
  2173.      case NODE_PUSH_MATRIX:
  2174.         glPushMatrix();
  2175.         break;
  2176.      case NODE_PUSH_NAME:
  2177.         glPushName( n[1].ui );
  2178.         break;
  2179.      case NODE_RASTER_POS:
  2180.         {
  2181.            GLfloat v[4];
  2182.            v[0] = n[1].f;
  2183.            v[1] = n[2].f;
  2184.            v[2] = n[3].f;
  2185.            v[3] = n[4].f;
  2186.            gl_rasterpos( v );
  2187.         }
  2188.         break;
  2189.      case NODE_READ_BUFFER:
  2190.         glReadBuffer( n[1].e );
  2191.         break;
  2192.      case NODE_SCISSOR:
  2193.         glScissor( n[1].i, n[2].i, n[3].i, n[4].i );
  2194.         break;
  2195.      case NODE_SET_BOOLEAN:
  2196.         if (INSIDE_BEGIN_END) {
  2197.            gl_error( GL_INVALID_OPERATION, "in display list" );
  2198.         }
  2199.         else {
  2200.            GLboolean *ptr;
  2201.            ptr = (GLboolean *) n[1].data;
  2202.            *ptr = n[2].b;
  2203.         }
  2204.         break;
  2205.      case NODE_SET_ENUM:
  2206.         if (INSIDE_BEGIN_END) {
  2207.            gl_error( GL_INVALID_OPERATION, "in display list" );
  2208.         }
  2209.         else {
  2210.            GLenum *ptr;
  2211.            ptr = (GLenum *) n[1].data;
  2212.            *ptr = n[2].e;
  2213.         }
  2214.         break;
  2215.      case NODE_SET_FLOAT:
  2216.         if (INSIDE_BEGIN_END) {
  2217.            gl_error( GL_INVALID_OPERATION, "in display list" );
  2218.         }
  2219.         else {
  2220.            GLfloat *ptr;
  2221.            ptr = (GLfloat *) n[1].data;
  2222.            *ptr = n[2].f;
  2223.         }
  2224.         break;
  2225.      case NODE_SET_INT:
  2226.         if (INSIDE_BEGIN_END) {
  2227.            gl_error( GL_INVALID_OPERATION, "in display list" );
  2228.         }
  2229.         else {
  2230.            GLint *ptr;
  2231.            ptr = (GLint *) n[1].data;
  2232.            *ptr = n[2].i;
  2233.         }
  2234.         break;
  2235.      case NODE_SET_UINT:
  2236.         if (INSIDE_BEGIN_END) {
  2237.            gl_error( GL_INVALID_OPERATION, "in display list" );
  2238.         }
  2239.         else {
  2240.            GLuint *ptr;
  2241.            ptr = (GLuint *) n[1].data;
  2242.            *ptr = n[2].ui;
  2243.         }
  2244.         break;
  2245.      case NODE_SHADE_MODEL:
  2246.         glShadeModel( n[1].e );
  2247.         break;
  2248.      case NODE_STENCIL_FUNC:
  2249.         glStencilFunc( n[1].e, n[2].i, n[3].ui );
  2250.         break;
  2251.      case NODE_STENCIL_MASK:
  2252.         glStencilMask( n[1].ui );
  2253.         break;
  2254.      case NODE_STENCIL_OP:
  2255.         glStencilOp( n[1].e, n[2].e, n[3].e );
  2256.         break;
  2257.          case NODE_TEXENV:
  2258.             {
  2259.                GLfloat params[4];
  2260.                params[0] = n[3].f;
  2261.                params[1] = n[4].f;
  2262.                params[2] = n[5].f;
  2263.                params[3] = n[6].f;
  2264.                gl_texenv( n[1].e, n[2].e, params );
  2265.             }
  2266.             break;
  2267.          case NODE_TEXGEN:
  2268.             {
  2269.                GLfloat params[4];
  2270.                params[0] = n[3].f;
  2271.                params[1] = n[4].f;
  2272.                params[2] = n[5].f;
  2273.                params[3] = n[6].f;
  2274.                gl_texgen( n[1].e, n[2].e, params );
  2275.             }
  2276.             break;
  2277.          case NODE_TEXPARAMETER:
  2278.             {
  2279.                GLfloat params[4];
  2280.                params[0] = n[3].f;
  2281.                params[1] = n[4].f;
  2282.                params[2] = n[5].f;
  2283.                params[3] = n[6].f;
  2284.                gl_texparameter( n[1].e, n[2].e, params );
  2285.             }
  2286.             break;
  2287.      case NODE_TEXIMAGE1D:
  2288.         gl_teximage1d( n[1].i, n[2].i, n[3].i, n[4].i,
  2289.                            (GLubyte *) n[5].data );
  2290.         break;
  2291.      case NODE_TEXIMAGE2D:
  2292.         gl_teximage2d( n[1].i, n[2].i, n[3].i, n[4].i, n[5].i,
  2293.                            (GLubyte *) n[6].data );
  2294.         break;
  2295.      case NODE_VIEWPORT:
  2296.         gl_viewport( n[1].i, n[2].i, (GLsizei) n[3].i, (GLsizei) n[4].i );
  2297.         break;
  2298.      case NODE_CONTINUE:
  2299.         n = (Node *) n[1].next;
  2300.         break;
  2301.      case NODE_END_OF_LIST:
  2302.         done = GL_TRUE;
  2303.         break;
  2304.      default:
  2305.         printf("Error in execute_list: %d\n", (int) k );
  2306.         gl_error( GL_INVALID_ENUM, "execute_list" );
  2307.       }
  2308.  
  2309.       /* increment n to point to next compiled command */
  2310.       if (k!=NODE_CONTINUE) {
  2311.      n += NodeSize[k];
  2312.       }
  2313.  
  2314.    }
  2315.    CC.CallDepth--;
  2316. }
  2317.  
  2318.  
  2319.  
  2320. /**********************************************************************/
  2321. /*                           GL functions                             */
  2322. /**********************************************************************/
  2323.  
  2324.  
  2325.  
  2326. /*
  2327.  * Test if a display list number is valid.
  2328.  */
  2329. GLboolean glIsList( GLuint list )
  2330. {
  2331.    if (list>0 && CC.ListGroup->List[list-1]) {
  2332.       return GL_TRUE;
  2333.    }
  2334.    else {
  2335.       return GL_FALSE;
  2336.    }
  2337. }
  2338.  
  2339.  
  2340.  
  2341. /*
  2342.  * Delete a sequence of consecutive display lists.
  2343.  */
  2344. void glDeleteLists( GLuint list, GLsizei range )
  2345. {
  2346.    GLuint i;
  2347.  
  2348.    if (INSIDE_BEGIN_END) {
  2349.       gl_error( GL_INVALID_OPERATION, "glDeleteLists" );
  2350.       return;
  2351.    }
  2352.    if (range<0) {
  2353.       gl_error( GL_INVALID_VALUE, "glDeleteLists" );
  2354.       return;
  2355.    }
  2356.  
  2357.    for (i=list;i<list+range;i++) {
  2358.       if (CC.ListGroup->List[i-1]) {
  2359.          destroy_list( i-1 );
  2360.          CC.ListGroup->List[i-1] = NULL;
  2361.      CC.ListGroup->Reserved[i-1] = GL_FALSE;
  2362.       }
  2363.    }
  2364. }
  2365.  
  2366.  
  2367.  
  2368. /*
  2369.  * Return a display list number, n, such that lists n through n+range-1
  2370.  * are free.
  2371.  */
  2372. GLuint glGenLists( GLsizei range )
  2373. {
  2374.    GLuint i, freecount;
  2375.  
  2376.    if (INSIDE_BEGIN_END) {
  2377.       gl_error( GL_INVALID_OPERATION, "glGenLists" );
  2378.       return 0;
  2379.    }
  2380.    if (range<=0) {
  2381.       gl_error( GL_INVALID_VALUE, "glGenLists" );
  2382.       return 0;
  2383.    }
  2384.  
  2385.    i = 0;
  2386.    freecount = 0;
  2387.    for (i=0; i<MAX_DISPLAYLISTS; i++ ) {
  2388.       if (CC.ListGroup->List[i]==NULL && CC.ListGroup->Reserved[i]==GL_FALSE) {
  2389.          freecount++;
  2390.          if (freecount==range) {
  2391.         /* we found 'range' consecutive free lists */
  2392.         GLuint k;
  2393.         GLuint n = i-range+2;
  2394.         for (k=n;k<n+range;k++) {
  2395.            CC.ListGroup->Reserved[k-1] = GL_TRUE;
  2396.         }
  2397.             return n;
  2398.          }
  2399.       }
  2400.       else {
  2401.          freecount = 0;
  2402.       }
  2403.    }
  2404.    return 0;
  2405. }
  2406.  
  2407.  
  2408.  
  2409. /*
  2410.  * Begin a new display list.
  2411.  */
  2412. void glNewList( GLuint list, GLenum mode )
  2413. {
  2414.    if (INSIDE_BEGIN_END) {
  2415.       gl_error( GL_INVALID_OPERATION, "glNewList" );
  2416.       return;
  2417.    }
  2418.    if (list==0 || list>MAX_DISPLAYLISTS) {
  2419.       gl_error( GL_INVALID_VALUE, "glNewList" );
  2420.       return;
  2421.    }
  2422.    if (mode!=GL_COMPILE && mode!=GL_COMPILE_AND_EXECUTE) {
  2423.       gl_error( GL_INVALID_ENUM, "glNewList" );
  2424.       return;
  2425.    }
  2426.    if (CurrentListPtr) {
  2427.       /* already compiling a display list */
  2428.       gl_error( GL_INVALID_OPERATION, "glNewList" );
  2429.       return;
  2430.    }
  2431.  
  2432.    /* Allocate new display list */
  2433.    CurrentListNum = list;
  2434.    CurrentListPtr = CurrentBlock = (Node *) malloc( sizeof(Node) * BLOCK_SIZE );
  2435.    CurrentPos = 0;
  2436.  
  2437.    CC.CompileFlag = GL_TRUE;
  2438.    if (mode==GL_COMPILE) {
  2439.       CC.ExecuteFlag = GL_FALSE;
  2440.       CC.VertexFunc = gl_save_vertex;
  2441.    }
  2442.    else {
  2443.       /* Compile and execute */
  2444.       CC.ExecuteFlag = GL_TRUE;
  2445.       CC.VertexFunc = gl_save_and_execute_vertex;
  2446.    }
  2447. }
  2448.  
  2449.  
  2450.  
  2451. /*
  2452.  * End definition of current display list.
  2453.  */
  2454. void glEndList( void )
  2455. {
  2456.    Node *n;
  2457.  
  2458.    /* Check that a list is under construction */
  2459.    if (!CurrentListPtr) {
  2460.       gl_error( GL_INVALID_OPERATION, "glEndList" );
  2461.       return;
  2462.    }
  2463.  
  2464.    n = alloc_nodes(1);
  2465.    n[0].kind = NODE_END_OF_LIST;
  2466.  
  2467.    /* Install the list */
  2468.    if (CC.ListGroup->List[CurrentListNum-1]) {
  2469.       destroy_list( CurrentListNum-1 );
  2470.    }
  2471.    CC.ListGroup->List[CurrentListNum-1] = CurrentListPtr;
  2472.  
  2473.    CurrentListNum = 0;
  2474.    CurrentListPtr = NULL;
  2475.    CC.ExecuteFlag = GL_TRUE;
  2476.    CC.CompileFlag = GL_FALSE;
  2477.    CC.VertexFunc = gl_execute_vertex;
  2478. }
  2479.  
  2480.  
  2481.  
  2482. void glCallList( GLuint list )
  2483. {
  2484.    if (CC.CompileFlag) {
  2485.       gl_save_call( list );
  2486.    }
  2487.    if (CC.ExecuteFlag) {
  2488.       /* VERY IMPORTANT:  Save the CompileFlag status, turn it off, */
  2489.       /* execute the display list, and restore the CompileFlag. */
  2490.       GLboolean save_compile_flag;
  2491.       save_compile_flag = CC.CompileFlag;
  2492.       CC.CompileFlag = GL_FALSE;
  2493.       execute_list( list );
  2494.       CC.CompileFlag = save_compile_flag;
  2495.    }
  2496. }
  2497.  
  2498.  
  2499.  
  2500. /*
  2501.  * Call multiple display lists.
  2502.  */
  2503. void glCallLists( GLsizei n, GLenum type, const GLvoid *lists )
  2504. {
  2505.    GLuint i, list;
  2506.  
  2507.    if (CC.CompileFlag) {
  2508.       for (i=0;i<n;i++) {
  2509.      list = translate_id( i, type, lists );
  2510.      gl_save_call_offset( list );
  2511.       }
  2512.    }
  2513.  
  2514.    if (CC.ExecuteFlag) {
  2515.       /* Save the CompileFlag status, turn it off, execute display list, */
  2516.       /* and restore the CompileFlag. */
  2517.       GLboolean save_compile_flag;
  2518.       save_compile_flag = CC.CompileFlag;
  2519.       CC.CompileFlag = GL_FALSE;
  2520.       for (i=0;i<n;i++) {
  2521.      list = translate_id( i, type, lists );
  2522.      execute_list( CC.List.ListBase + list );
  2523.       }
  2524.       CC.CompileFlag = save_compile_flag;
  2525.    }
  2526. }
  2527.  
  2528.  
  2529.  
  2530. /*
  2531.  * Set the offset added to list numbers in glCallLists.
  2532.  */
  2533. void glListBase( GLuint base )
  2534. {
  2535.    if (CC.CompileFlag) {
  2536.       gl_save_listbase( base );
  2537.    }
  2538.    if (CC.ExecuteFlag) {
  2539.       if (INSIDE_BEGIN_END) {
  2540.      gl_error( GL_INVALID_OPERATION, "glListBase" );
  2541.      return;
  2542.       }
  2543.       CC.List.ListBase = base;
  2544.    }
  2545. }
  2546.  
  2547.